home *** CD-ROM | disk | FTP | other *** search
/ Netware Super Library / Netware Super Library.iso / pgm_tool / lu62 / debug / ftt3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-03  |  17.9 KB  |  661 lines
  1. /*
  2.  *  CopyRight 1995. Nicholas Poljakov all rights reserved.
  3.  */
  4. #include <dos.h>
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <io.h>
  8. #include <conio.h>
  9. #include <fcntl.h>
  10. #include <malloc.h>
  11. #include <stdlib.h>
  12. #include <direct.h>
  13.  
  14. #define BORDER 1
  15. #define REV_VID 0x70
  16. #define NORM_VID 0x1E
  17. #define MAX_FRAME 31
  18. #define BKSP 8
  19. #define F1 59
  20. #define F2 60
  21. #define F3 61
  22. #define F4 62
  23. #define F5 63
  24. #define F6 64
  25. #define F7 65
  26. #define F8 66
  27. #define F9 67
  28. #define F10 68
  29. #define HM  71   /* Home key     */
  30. #define UP  72   /* Up Arrow     */
  31. #define PU  73   /* Page Up      */
  32. #define LT  75   /* Left Arrow   */
  33. #define RT  77   /* Right Arrow  */
  34. #define END 79   /* End key      */
  35. #define DN  80   /* Down Arrow   */
  36. #define PD  81   /* Page Down    */
  37. #define ESC '\033'
  38. #define DIR 0x10
  39.  
  40. #define ROWS1 19
  41. #define ROWS2 23
  42. #define ROWS  25
  43. #define COLS 78
  44. #define L_W 20
  45. #define M_W 36
  46. #define R_W 20
  47. #define SCRNSIZE ((ROWS)*(COLS+2)*2)
  48. #define LAST (24 * 80)*2
  49.  
  50. #define M0C  4     /* Files maping col.s */
  51. #define M0L  10    /* Files maping rows  */
  52. #define M0F (((80 * 9) + 12)) * 2
  53. #define INTR 15*2
  54.  
  55. struct find_t find;
  56. extern void **ptrs;
  57. extern int size;
  58. extern unsigned char row, col;
  59. extern int adapter;
  60. extern unsigned char far *videomem;
  61. extern int offset;
  62. extern int sw;
  63. extern char path[18];
  64. extern char file[12];
  65. extern char tpname[31];
  66. extern char lu_name[9];
  67. extern char mode_name[8];
  68. extern char rcv_file[12];
  69. extern char dta[128];
  70. extern char pi[40];
  71. extern char *pa[2];
  72.  
  73. extern char far *sv;
  74. extern char far *vid_mem;
  75. extern short cur_ln;
  76.  
  77. extern struct menu_frame {
  78.     int startx, endx, starty, endy;
  79.     unsigned char *p;
  80.     char **menu;
  81.     char *keys;
  82.     int border;
  83.     int count;
  84.     unsigned char attrib;
  85.     int active;
  86.     int curx, cury;
  87.     char *header;
  88.     unsigned char shd;
  89.     } frame[MAX_FRAME];
  90.  
  91. extern struct  part  {     /* partner structure */
  92.                   char   plu[8] ;             /* str plu_name        */
  93.                   int psl;                    /* str plu_s_limit     */
  94.                   char   mode_name[8] ;       /* str mode_name       */
  95.                   int max_ru_size;            /* str ru_h_size       */
  96.                   int pacing;                 /* str =               */
  97.                   unsigned char lu_type;
  98.                }  pstr[4];
  99. extern char p_dcl[21];
  100. extern unsigned char dr_ind[80];
  101. extern char c_pt[60];
  102. extern int drive_ind[10];
  103. extern char *topline[];
  104. extern char *btline[];
  105. extern char CurFile[14];
  106. extern ExeFl(char *,int);
  107. extern RemCom(int);
  108.  
  109. menu0(video, to, from)
  110. char far *video;
  111. int to;
  112. int from;
  113. {
  114.    struct f_name {
  115.                    struct f_name *next;
  116.                    struct f_name *prev;
  117.                    char   ind;
  118.                    unsigned int time;
  119.                    unsigned int date;
  120.                    unsigned long int size;
  121.                    char   name[12];
  122.                   } *el;
  123.    int cnt, t_cnt;
  124.    int i, j, k, l, m, max, incr;
  125.    int dest;
  126.    struct f_name *c_ptr;
  127.    struct f_name *e_ptr;
  128.    void *s_chain;     /* pointer to begin of chain */
  129.    void *e_chain;     /* pointer to    end  of chain */
  130.    char ch;
  131.    char *p;
  132.    char *pt;
  133.    div_t result;
  134.    int hor;
  135.    int min;
  136.    int sec;
  137.    int yer;
  138.    int mth;
  139.    int day;
  140.    char buff[18];
  141.    unsigned tmp1;
  142.    unsigned tmp2;
  143.    char info[70];
  144.    union REGS regs;
  145. /*
  146.    int b_chain();
  147.    int map();
  148.    int move();
  149.    int reset();
  150.    int f_chain(void *, void *, void *, int);
  151. */
  152.    Retry : cnt = t_cnt = 0;
  153.    sw = 0;
  154.    if (b_chain(&s_chain, &e_chain, &max, from) == 1) {
  155.          window(27);
  156.          window_xy(27, 1, 0);
  157.          window_puts(27, "File not found. Reset mask.");
  158.          window_xy(27, 2, 0);
  159.          if (window_gets(27, buff) == 1) { /* read local LU name */
  160.              deactivate(27);
  161.              return 0;
  162.          }
  163.          strcpy(path, buff);
  164.          deactivate(27);
  165.          goto Retry;
  166.    }
  167.    e_ptr = c_ptr = s_chain;
  168.    map(video, c_ptr, from); /* maps to screen names of files */
  169.  
  170.    k = j = 0;
  171.    ch = REV_VID;
  172.    r0set(video, j, k, ch);
  173.    sfs(sv, vid_mem);
  174.    save_video(0);
  175.    save_video(1);
  176. Repete:
  177.    write_string(0, 0, topline[0], frame[0].attrib);
  178.    write_string(0, 8, topline[1], frame[0].attrib);
  179.    write_string(0, 16, topline[2], frame[0].attrib);
  180.    write_string(0, 74, topline[3], frame[0].attrib);
  181.  
  182.    write_string(24, 0, btline[0], frame[1].attrib);
  183.    write_string(24, 10, btline[1], frame[1].attrib);
  184.    write_string(24, 20, btline[2], frame[1].attrib);
  185.    write_string(24, 30, btline[5], frame[1].attrib);
  186.    write_string(24, 44, btline[3], frame[1].attrib);
  187.    write_string(24, 57, btline[4], frame[1].attrib);
  188.    write_string(20, 9, "                                                    ", frame[8].attrib);
  189.    sfs(sv, vid_mem);
  190.  
  191.    while ((ch = getch()) != ESC) {
  192.         if (ch == '\r') {
  193.                      if (e_ptr -> ind == DIR) {
  194.  
  195.                       ch = frame[8].attrib;
  196.                       r0set(video, j, k, ch);
  197.                       if (from) {
  198.                           rem_cd(e_ptr, from - 1);
  199.                       }
  200.                       else
  201.                           cd(e_ptr);
  202.                       f_chain(s_chain); /* free chain's memory */
  203.                       goto Retry;
  204.                      }
  205.                      ch = frame[8].attrib;
  206.                      r0set(video, j, k, ch);
  207.              ExeFl(CurFile,from);
  208.                      strcpy(file,(*e_ptr).name);  /* file is el. of global struct */
  209.         }
  210.         if (ch == 9) { /* Tab */
  211.             return 2;
  212.         }
  213.         if (ch == 0)
  214.            {
  215.               i = j;   /* save j */
  216.               switch (ch = getch()) {
  217.                   case UP :
  218.                   {
  219.                       j--;
  220.                       break;
  221.                   }
  222.                   case DN :
  223.                   {
  224.                       j++;
  225.                       break;
  226.                   }
  227.                   case LT :
  228.                   {
  229.                       j -= M0L;
  230.                       break;
  231.                   }
  232.                   case RT :
  233.                   {
  234.                       j += M0L;
  235.                       break;
  236.                   }
  237.                   case F3 :
  238.           {
  239.                pv(CurFile);
  240.                        goto Repete;
  241.                   }
  242.                   case F5 :
  243.                   {
  244.                        if (from == 0) {
  245.                          if (to == 0) {
  246.                               CpyFile(CurFile);
  247.                          }
  248.                          else
  249.                   SendFil(CurFile, to);
  250.                        }
  251.                        else
  252.                               if (to == 0) {
  253.                   RcvFile(CurFile, from);
  254.                               }
  255.                   else
  256.                   if (from == to)
  257.                     ROCopy(CurFile, from);
  258.                   else
  259.                     RmtCopy(CurFile, from, to);
  260.                        goto Repete;
  261.                   }
  262.                   case F8 :{
  263.                              if (from == 0) {
  264.                                 dest = to;
  265.                              }
  266.                              else
  267.                                 dest = from;
  268.                              RemCom(dest);
  269.                              goto Repete;
  270.                   }
  271.                   case F9 :
  272.                   {
  273.                ch = frame[8].attrib;
  274.                r0set(video, i, k, ch);
  275.                window(27);
  276.                        window_xy(27, 1, 0);
  277.                        window_puts(27, "Enter the File mask  please");
  278.                        window_xy(27, 2, 0);
  279.                        if (window_gets(27, buff) == 1) { /* read local LU name */
  280.                            deactivate(27);
  281.                            break;
  282.                        }
  283.                        strcpy(path, buff);
  284.                        deactivate(27);
  285.                        goto Retry;
  286.                   }
  287.                   case F10 :
  288.                   {
  289.                        write_string(0, 0, topline[0], REV_VID);
  290.                i = pr_m0();
  291.                /*
  292.                if (i == -1) {
  293.                restore_video(0);
  294.                return 0;
  295.                }
  296.                */
  297.                goto Repete;
  298.           }
  299.  
  300.                   default:
  301.                           goto Repete;
  302.            }
  303.  
  304.                if (j < k)
  305.                       {
  306.                           if (j < 0) {
  307.                   j = 0;
  308.                   ch = frame[8].attrib;
  309.                   r0set(video, i, k, ch);
  310.                   k = j;
  311.                           }
  312.                           c_ptr = ptrs[k];
  313.                           map(video, c_ptr, from);
  314.                       }
  315.                if (j > k + max - 1) {
  316.           if (j > size - 1) {
  317.               j = size - 1;
  318.               ch = frame[8].attrib;
  319.               r0set(video, i, k, ch);
  320.                       k = size - max;
  321.                       c_ptr = ptrs[k];
  322.                       map(video, c_ptr, from);
  323.               ch = frame[8].attrib;
  324.                       r0set(video, 0, 0, ch);
  325.  
  326.                   }
  327.           else
  328.               {
  329.               ch = frame[8].attrib;
  330.               r0set(video, i, k, ch);
  331.               k = j - max + 1;
  332.                           c_ptr = ptrs[k];
  333.                           map(video, c_ptr, from);
  334.               ch = frame[8].attrib;
  335.                           r0set(video, 0, 0, ch);
  336.               }
  337.            }
  338.        ch = frame[8].attrib;
  339.            r0set(video, i, k, ch);
  340.            ch = 0x70;
  341.            r0set(video, j, k, ch);
  342.            e_ptr = ptrs[j];
  343.                if (e_ptr -> ind != DIR) {
  344.            p = e_ptr -> name;
  345.                    tmp1 = e_ptr -> time;
  346.                    tmp2 = e_ptr -> date;
  347.                    _asm
  348.                         {
  349.                             mov  ax, word ptr tmp1[0]
  350.                             and  ax, 0000000000011111b
  351.                             mov  word ptr sec[0], ax
  352.                             mov  ax, word ptr tmp1[0]
  353.                             and  ax, 0000011111100000b
  354.                             mov  cx, 5
  355.                             shr  ax, cl
  356.                             mov  word ptr min[0], ax
  357.                             mov  ax, word ptr tmp1[0]
  358.                             and  ax, 1111100000000000b
  359.                             mov  cx, 11
  360.                             shr  ax, cl
  361.                             mov  word ptr hor[0], ax
  362.  
  363.                             mov  ax, word ptr tmp2[0]
  364.                             and  ax, 0000000000011111b
  365.                             mov  word ptr day[0], ax
  366.                             mov  ax, word ptr tmp2[0]
  367.                             and  ax, 0000000111100000b
  368.                             mov  cx, 5
  369.                             shr  ax, cl
  370.                             mov  word ptr mth[0], ax
  371.                             mov  ax, word ptr tmp2[0]
  372.                             and  ax, 1111111000000000b
  373.                             mov  cx, 9
  374.                             shr  ax, cl
  375.                             mov  word ptr yer[0], ax
  376.                         }
  377.            sprintf(info, "%-18s   %u:%2.2u:%2.2u  %2.2u:%2.2u:%2.2u  %lu", p, 1980+yer,day,mth,hor,min,sec, e_ptr->size);
  378.            write_string(20, 12, "                                                    ", frame[8].attrib);
  379.            write_string(20, 12, info, frame[8].attrib | 0x0f);
  380.                    strcpy(CurFile, p);
  381.            }
  382.            else
  383.            write_string(20, 9, "                                                    ", frame[8].attrib);
  384.        }
  385.    }
  386.        ch = frame[8].attrib;
  387.        r0set(video, j, k, ch);
  388.        restore_video(1);
  389.        restore_video(0);
  390.        return(0);
  391. }
  392. b_chain(s_chain, e_chain, max, from)
  393. void **s_chain;
  394. void **e_chain;
  395. int *max;
  396. int from;
  397. {
  398.   #define MAX  M0L*4
  399.    int l, i, j;
  400.    struct f_name {
  401.                    struct f_name *next;
  402.                    struct f_name *prev;
  403.                    char   ind;
  404.                    unsigned int time;
  405.                    unsigned int date;
  406.                    unsigned long int size;
  407.            char   name[13];
  408.                   } *el;
  409.    struct f_name *t_ptr;
  410.    struct dt {
  411.                 char reserv[21];
  412.                 char attr;
  413.                 unsigned int time;
  414.                 unsigned int date;
  415.                 unsigned long int size;
  416.                 char name[18];
  417.           }  *s_dta;
  418.    char *p;
  419.  
  420.    s_dta = dta;
  421.    p = s_dta;
  422.    strset(p,0x00);
  423.    i = 0;
  424.    *s_chain = NULL;
  425.    *e_chain = NULL;
  426.    t_ptr = NULL;
  427.    while ((get_f(s_dta, from)) != -1) {
  428.         i++;
  429.         l = strlen((*s_dta).name);
  430.         l += 18; /* length of chain el. large model */
  431.         if ((el = (char *)malloc(l)) == NULL) {
  432.            return -1;
  433.     }
  434.     strcpy(el -> name, s_dta -> name);
  435.         el -> size = s_dta -> size;
  436.         el -> time = s_dta -> time;
  437.         el -> date = s_dta -> date;
  438.         if ((*s_dta).attr != DIR )  strlwr((*el).name);
  439.         (*el).next = NULL;
  440.         (*el).ind = (*s_dta).attr;
  441.         if ( i == 1 ) {
  442.         *s_chain = el;
  443.         t_ptr = el;
  444.         }
  445.         else
  446.                {
  447.                   t_ptr -> next = el;
  448.           el -> prev = t_ptr;
  449.           t_ptr = el;
  450.                }
  451.    }
  452.    if (*s_chain == NULL) {
  453.         return 1;
  454.    }
  455.    *e_chain = t_ptr;
  456.    if (i > MAX) {
  457.       *max = MAX;
  458.    }
  459.    else *max = i;
  460.    size = i;
  461.    ptrs = malloc(i*4); /* large model */
  462.    t_ptr = ptrs[0] = *s_chain;
  463.    for (l = 1; l < i; l++) {
  464.     ptrs[l] = t_ptr -> next;
  465.     if((t_ptr = t_ptr -> next) == NULL) {
  466.         break;
  467.     }
  468.    }
  469. }
  470. get_f(s_dta, from)
  471. struct dt {
  472.          char reserv[21];
  473.          char attr;
  474.          unsigned int time;
  475.          unsigned int date;
  476.          unsigned long int size;
  477.          char name[18];
  478.        }  *s_dta;
  479. int from;
  480. {
  481.        union  REGS  regs;
  482.        struct SREGS segregs;
  483.        char *p;
  484.     if (from == 0) {
  485.          if (sw == 0) {
  486.              if( _dos_findfirst( path, 0xffff, &find ) )
  487.                  return -1;
  488.              sw++;
  489.              if ((strlen(find.name) != 1) | (find.name[0] != '.'))
  490.                 goto GetEx;
  491.          }
  492.          if( _dos_findnext( &find ) )
  493.             return (-1);
  494.          GetEx:
  495.          memcpy(s_dta, &find, sizeof(struct find_t));
  496.          return 0;
  497.     }
  498.     else
  499.      return rem_getf(s_dta, from);
  500. }
  501. map(video, e_ptr, from)
  502.     char far *video;
  503.     struct f_name {
  504.                     struct f_name *next;
  505.                     struct f_name *prev;
  506.                     char   ind;
  507.                     unsigned int time;
  508.                     unsigned int date;
  509.                     unsigned long int size;
  510.                     char   name[12];
  511.                    } *e_ptr;
  512.     int from;
  513. {
  514.     #define LS    60
  515.     union REGS regs;
  516.     char p_buf[64];
  517.     char drive;
  518.     int of;
  519.     int i, j, k, l, incr, incr0;
  520.     char *t;
  521.     unsigned char attr;
  522.  
  523.     _getdcwd(0, c_pt, _MAX_PATH);
  524.     write_string(7, 13, "        ", frame[8].attrib);
  525.     strcpy(dr_ind, "Source : ");
  526.     if (from == 0) {
  527.        strcat(dr_ind, lu_name);
  528.     }
  529.     else
  530.        strcat(dr_ind, pstr[from-1].plu);
  531.     write_string(7, 13, dr_ind, frame[8].attrib | 0x0f);
  532.     strcpy(dr_ind, p_dcl);
  533.     strcat(dr_ind, pa[0]);
  534.     write_string(7, 28, "                                        ", frame[8].attrib);
  535.     attr = frame[8].attrib;
  536.     if (attr == 0x1e) {
  537.         attr &= 0xf0;
  538.     attr |= 0x0c;
  539.     }
  540.     else
  541.         attr &= 0xf0;
  542.  
  543.     write_string(7, 28, dr_ind, attr);
  544.  
  545.     incr0 = M0F;
  546.     for (i = 0; i < M0L; i++, incr0 += 160) {
  547.         l = 0;
  548.        for (j = 0; j < LS; j++, l += 2)
  549.            *(video + incr0 + l) = ' ';
  550.      }
  551.  
  552.     incr0 = M0F;
  553.     for (i = 0; i < M0C; i++, incr0 += INTR)
  554.         {
  555.            of = incr0;
  556.            for (j = 0; j < M0L; j++, of +=160)
  557.                {
  558.                  incr = of;
  559.                  l = strlen((*e_ptr).name);
  560.                  t = (*e_ptr).name;
  561.                  for (k = 0; k < l; k++, incr += 2, t++)
  562.                       *(video + incr) = *t;
  563.                  if (e_ptr -> next == NULL)
  564.                       goto e_map;
  565.                  e_ptr = e_ptr -> next;
  566.                }
  567.     }
  568.     e_map :
  569.  
  570.     regs.h.ah = 0x47;
  571.     regs.h.dl = 0;
  572.     regs.x.si = &p_buf;
  573.     int86(0x21, ®s, ®s);
  574.     regs.h.ah = 0x19;
  575.     int86(0x21, ®s, ®s);
  576.     drive = regs.h.al + 0x41;
  577.  
  578.     return(0);
  579. }
  580. f_chain(s_chain)
  581. void **s_chain;
  582. {
  583.     struct f_name {
  584.                     struct f_name *next;
  585.                     struct f_name *prev;
  586.                     char   ind;
  587.                     unsigned int time;
  588.                     unsigned int date;
  589.                     unsigned long int size;
  590.                     char   name[12];
  591.                    } *e_ptr;
  592.     struct f_name *temp;
  593.  
  594.     e_ptr = *s_chain;
  595.     while (e_ptr != NULL) {
  596.         temp = e_ptr -> next;
  597.         free(e_ptr);
  598.         e_ptr = temp;
  599.     }
  600.     free(ptrs);
  601.     return (0);
  602. }
  603. r0set(video, i, k, attr)
  604. int i, k;
  605. char _far *video;
  606. char attr;
  607. {
  608.     /* i - old position;
  609.      * k - start position.
  610.      */
  611.     int incr, l, m, row, col;
  612.     div_t result;
  613.  
  614.     m = i - k;
  615.     result = div(m, M0L);
  616.     col = result.quot;
  617.     row = result.rem;
  618.     incr = row * 160 + col * INTR + M0F + 1;
  619.     for (l = 0; l < 12; l++, incr += 2)
  620.         *(video + incr) = attr;
  621.  
  622. }
  623. cd(e_ptr)
  624. struct f_name {
  625.                 struct f_name *next;
  626.                 struct f_name *prev;
  627.                 char   ind;
  628.                 unsigned int time;
  629.                 unsigned int date;
  630.                 unsigned long int size;
  631.                 char   name[12];
  632.                } *e_ptr;
  633. {
  634.     struct SREGS segregs;
  635.     union REGS regs;
  636.     char _far *buffer;
  637.         char c_pt[40];
  638.  
  639.     regs.h.ah = 0x3b;
  640.     buffer = (*e_ptr).name;
  641.     regs.x.dx = FP_OFF( buffer );
  642.     segregs.ds = FP_SEG( buffer );
  643.     intdosx( ®s, ®s, &segregs );
  644.     if (regs.x.cflag == 0) {
  645.         _getdcwd(0, c_pt, _MAX_PATH);
  646.          strcpy(pi, c_pt);
  647.          return(0);
  648.     }
  649.     else return(-1);
  650. }
  651. ch_drive(num)
  652. int num;
  653. {
  654.     union REGS regs;
  655.  
  656.     regs.h.ah = 0x0e;
  657.     regs.h.dl = num;
  658.     int86(0x21, ®s, ®s);
  659.     return 0;
  660. }
  661.